import 'dart:io';
import 'package:logging/logging.dart';
import 'package:path_provider/path_provider.dart';

import 'datetime_formatter.dart';

// 引入上面的DateTimeFormatter工具类
// import 'datetime_formatter.dart';

/// 使用DateTimeFormatter的日志管理器示例
class LoggerWithDateTime {
  static final Logger _logger = Logger('MyApp');
  static File? _logFile;
  static bool _isInitialized = false;

  /// 初始化日志系统
  static Future<void> init() async {
    if (_isInitialized) return;

    // 获取应用文档目录
    final directory = await getApplicationDocumentsDirectory();
    final logDir = Directory('${directory.path}/logs');

    // 创建日志目录
    if (!await logDir.exists()) {
      await logDir.create(recursive: true);
    }

    // 创建日志文件，按日期命名
    final fileName = DateTimeFormatter.generateDailyLogFileName('app', '.log');
    _logFile = File('${logDir.path}/$fileName');

    // 设置日志级别
    Logger.root.level = Level.ALL;

    // 监听日志记录
    Logger.root.onRecord.listen((record) {
      final formattedMessage = _formatLogRecord(record);
      print(formattedMessage); // 输出到控制台
      _writeToFile(formattedMessage); // 写入文件
    });

    _isInitialized = true;

    // 记录初始化日志
    info('日志系统初始化完成');
  }

  /// 格式化日志记录
  static String _formatLogRecord(LogRecord record) {
    final timestamp = DateTimeFormatter.format(record.time);
    final level = record.level.name.padRight(7);
    final loggerName = record.loggerName;
    final message = record.message;

    String formattedMessage = '[$timestamp] [$level] [$loggerName] $message';

    // 如果有异常信息，添加到日志中
    if (record.error != null) {
      formattedMessage += '\n错误: ${record.error}';
    }

    // 如果有堆栈跟踪，添加到日志中
    if (record.stackTrace != null) {
      formattedMessage += '\n堆栈跟踪:\n${record.stackTrace}';
    }

    return formattedMessage;
  }

  /// 写入文件
  static void _writeToFile(String message) {
    try {
      _logFile?.writeAsStringSync('$message\n', mode: FileMode.append);
    } catch (e) {
      print('写入日志文件失败: $e');
    }
  }

  /// 记录调试信息
  static void debug(String message) {
    _logger.fine(message);
  }

  /// 记录一般信息
  static void info(String message) {
    _logger.info(message);
  }

  /// 记录警告信息
  static void warning(String message) {
    _logger.warning(message);
  }

  /// 记录错误信息
  static void error(String message, [dynamic error, StackTrace? stackTrace]) {
    _logger.severe(message, error, stackTrace);
  }

  /// 记录致命错误
  static void fatal(String message, [dynamic error, StackTrace? stackTrace]) {
    _logger.shout(message, error, stackTrace);
  }

  /// 记录性能信息
  static void performance(String operation, DateTime startTime, [DateTime? endTime]) {
    endTime ??= DateTime.now();
    final duration = DateTimeFormatter.getDuration(startTime, endTime);
    info('性能统计 - $operation: 耗时 $duration');
  }

  /// 记录用户行为
  static void userAction(String action, {Map<String, dynamic>? data}) {
    final timestamp = DateTimeFormatter.now();
    final dataString = data != null ? ' 数据: $data' : '';
    info('用户行为 - $action (时间: $timestamp)$dataString');
  }

  /// 记录网络请求
  static void networkRequest(String method, String url, int statusCode, DateTime startTime) {
    final duration = DateTimeFormatter.getDuration(startTime);
    info('网络请求 - $method $url 状态码: $statusCode 耗时: $duration');
  }

  /// 记录应用生命周期
  static void lifecycle(String event) {
    info('应用生命周期 - $event (时间: ${DateTimeFormatter.now()})');
  }

  /// 清理旧日志文件
  static Future<void> cleanOldLogs({int keepDays = 7}) async {
    try {
      final directory = await getApplicationDocumentsDirectory();
      final logDir = Directory('${directory.path}/logs');

      if (await logDir.exists()) {
        final files = await logDir.list().toList();
        final cutoffDate = DateTime.now().subtract(Duration(days: keepDays));

        for (final entity in files) {
          if (entity is File && entity.path.endsWith('.log')) {
            final stat = await entity.stat();
            if (stat.modified.isBefore(cutoffDate)) {
              await entity.delete();
              info('删除旧日志文件: ${entity.path}');
            }
          }
        }
      }
    } catch (e) {
      error('清理旧日志文件失败', e);
    }
  }

  /// 获取日志文件路径
  static String? getLogFilePath() {
    return _logFile?.path;
  }

  /// 获取日志文件大小
  static Future<int?> getLogFileSize() async {
    try {
      if (_logFile != null && await _logFile!.exists()) {
        final stat = await _logFile!.stat();
        return stat.size;
      }
    } catch (e) {
      error('获取日志文件大小失败', e);
    }
    return null;
  }
}

/* 使用示例
void main() async {
  // 初始化日志系统
  await LoggerWithDateTime.init();

  // 基本使用示例
  print('=== 基本时间格式化示例 ===');
  print('当前时间（默认格式）: ${DateTimeFormatter.now()}');
  print('当前时间（紧凑格式）: ${DateTimeFormatter.nowCompact()}');
  print('当前时间（详细格式）: ${DateTimeFormatter.nowDetailed()}');
  print('文件名格式: ${DateTimeFormatter.nowForFileName()}');
  print('当前日期: ${DateTimeFormatter.currentDate()}');
  print('当前时间: ${DateTimeFormatter.currentTime()}');
  print('时间戳: ${DateTimeFormatter.timestamp()}');

  print('\n=== 自定义格式化示例 ===');
  final customTime = DateTime(2024, 1, 15, 14, 30, 25, 123);
  print('自定义格式1: ${DateTimeFormatter.format(customTime, 'yyyy年MM月dd日 HH:mm:ss')}');
  print('自定义格式2: ${DateTimeFormatter.format(customTime, 'MM/dd/yyyy HH:mm')}');

  print('\n=== 时间戳格式化示例 ===');
  final timestamp = DateTime.now().millisecondsSinceEpoch;
  print('毫秒时间戳格式化: ${DateTimeFormatter.formatMilliseconds(timestamp)}');

  print('\n=== 相对时间示例 ===');
  final oneHourAgo = DateTime.now().subtract(const Duration(hours: 1));
  print('一小时前: ${DateTimeFormatter.getRelativeTime(oneHourAgo)}');

  print('\n=== 时间间隔示例 ===');
  final startTime = DateTime.now().subtract(const Duration(hours: 2, minutes: 30));
  print('时间间隔: ${DateTimeFormatter.getDuration(startTime)}');

  print('\n=== 文件名生成示例 ===');
  print('日志文件名: ${DateTimeFormatter.generateLogFileName()}');
  print('每日日志文件名: ${DateTimeFormatter.generateDailyLogFileName()}');

  print('\n=== 友好时间显示示例 ===');
  print('友好时间: ${DateTimeFormatter.getFriendlyTime(DateTime.now())}');

  print('\n=== 日志记录示例 ===');
  LoggerWithDateTime.debug('这是一条调试信息');
  LoggerWithDateTime.info('应用启动成功');
  LoggerWithDateTime.warning('这是一条警告信息');
  LoggerWithDateTime.error('这是一条错误信息');

  // 性能监控示例
  final performanceStart = DateTime.now();
  // 模拟一些操作
  await Future.delayed(const Duration(milliseconds: 100));
  LoggerWithDateTime.performance('数据库查询', performanceStart);

  // 用户行为记录示例
  LoggerWithDateTime.userAction('点击按钮', data: {'button': 'login', 'screen': 'main'});

  // 网络请求记录示例
  final requestStart = DateTime.now();
  await Future.delayed(const Duration(milliseconds: 200));
  LoggerWithDateTime.networkRequest('GET', 'https://api.example.com/users', 200, requestStart);

  // 应用生命周期记录示例
  LoggerWithDateTime.lifecycle('应用启动');

  // 获取日志文件信息
  print('\n=== 日志文件信息 ===');
  print('日志文件路径: ${LoggerWithDateTime.getLogFilePath()}');
  final logSize = await LoggerWithDateTime.getLogFileSize();
  if (logSize != null) {
    print('日志文件大小: ${logSize} bytes');
  }

  // 清理旧日志（示例，实际使用时可能在应用启动时调用）
  await LoggerWithDateTime.cleanOldLogs(keepDays: 30);
}
*/